package perceptron;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import algorithm.classification.binary.PerceptronLoss_L2Regularized;
import data.dictionary.Dictionary_Memory;
import data.vectors.DoubleVector;

/**
 * Résultats d'une analyse PAR UN PERCEPTRON.
 * @author simon
 *
 */
public class PerceptronResults extends Results {

	/**
	 * @param class1
	 * @param d
	 * @param m
	 */
	public PerceptronResults(String class1, Double d, Map<String, String> m) {
		super(class1, d, m);
	}
	
	/**
	 * Cette fonction calcule, à partir d'un dico et d'un perceptron, l'attribut word2colorsABS
	 * @param dico le dico utilisé lors de l'analyse.
	 * @param percept le perceptron utilisé lors de l'analyse.
	 */
	public void computeColorsABS(Dictionary_Memory<String> dico, PerceptronLoss_L2Regularized percept)  {
		
		/* HashMap temporaire contenant à terme les couple mot->poid dans le dico */
		HashMap<String,Double> temp = new HashMap<String,Double>() ;
		
		/* Pour chaque mot du document...*/
		Iterator<String> it = word2stem.keySet().iterator() ;
		while(it.hasNext()) {
			String currentKey=it.next() ;
			/* ... Il nous faut chercher l'indice du stemme correspondant dans le dico... */
			int stemIndex = dico.indexOf(word2stem.get(currentKey)) ;
			/* ... puis trouver le poid de ce stemme dans le perceptron... */
			double stemWeight = percept.getWeight().getValue(stemIndex) ;
			/* ... et enfin ajouter ce couple mot->poid à la Map. */
			/* On ne tient compte que de ceux ayant le même signe que le score */
			/* On ne garde que la valeur absolue des poids */
			if(stemWeight*score>=0) {
				temp.put(currentKey,stemWeight*(score >= 0 ? 1 : -1)) ;
			}
		}
		
		/* Ensuite, nous devons normaliser les valeurs sur l'interval d'entiers 0-255. */
		/* On commence par rechercher la valeur max */
		it=temp.keySet().iterator() ;
		double max = 0 ;
		while(it.hasNext()) {
			String currentKey=it.next() ;
			double currentWeight=temp.get(currentKey) ;
			if(currentWeight>max)
				max=currentWeight ;

		}
		
		
		/* A ce stage, max contient le plus fort poid en valeur absolue */
		/* Reste plus qu'à normaliser les poids */
		it=temp.keySet().iterator() ;
		this.word2colorABS=new HashMap<String,Integer>() ;
		while(it.hasNext()) {
			String currentKey=it.next() ;
			double currentWeight=temp.get(currentKey) ;
			/* On garde seulement la partie entière, et on exclue le cas nul */
			if((int)((currentWeight / max) * 255)!=0)
				word2colorABS.put(currentKey, (int)((currentWeight / max) * 255)) ;
		}
		
	}
	
	
	/**
	 * Cette fonction calcule, à partir d'un dico et d'un perceptron, l'attribut word2colorsREL
	 * @param dico le dico utilisé lors de l'analyse.
	 * @param percept le perceptron utilisé lors de l'analyse.
	 */
	public void computeColorsREL(Dictionary_Memory<String> dico, DoubleVector docVector, PerceptronLoss_L2Regularized percept)  {
		
		/* HashMap temporaire contenant à terme les couple mot->poid dans le dico */
		HashMap<String,Double> temp = new HashMap<String,Double>() ;
		
		/* Pour chaque mot du document...*/
		Iterator<String> it = word2stem.keySet().iterator() ;
		while(it.hasNext()) {
			String currentKey=it.next() ;
			/* ... Il nous faut chercher l'indice du stemme correspondant dans le dico... */
			int stemIndex = dico.indexOf(word2stem.get(currentKey)) ;
			/* ... puis trouver le poid de ce stemme dans le perceptron... */
			double stemWeight = percept.getWeight().getValue(stemIndex) ;
			/* ... ainsi que le fréquence du mot dans le document... */
			double stemPondWeight = stemWeight*docVector.getValue(stemIndex) ;
			/* ... et enfin ajouter ce couple mot->poid pondéré à la Map. */
			/* On ne tient compte que de ceux ayant le même signe que le score */
			/* On ne garde que la valeur absolue des poids */
			if(stemWeight*score>=0) {
				temp.put(currentKey,stemPondWeight*(score >= 0 ? 1 : -1)) ;
			}
		}
		
		/* Ensuite, nous devons normaliser les valeurs sur l'interval d'entiers 0-255. */
		/* On commence par rechercher la valeur max */
		it=temp.keySet().iterator() ;
		double max = 0 ;
		while(it.hasNext()) {
			String currentKey=it.next() ;
			double currentPondWeight=temp.get(currentKey) ;
			if(currentPondWeight>max)
				max=currentPondWeight ;

		}
		
		
		/* A ce stage, max contient le plus fort poid en valeur absolue */
		/* Reste plus qu'à normaliser les poids */
		it=temp.keySet().iterator() ;
		this.word2colorREL=new HashMap<String,Integer>() ;
		while(it.hasNext()) {
			String currentKey=it.next() ;
			double currentPondWeight=temp.get(currentKey) ;
			/* On garde seulement la partie entière, et on exclue le cas nul */
			if((int)((currentPondWeight / max) * 255)!=0)
				word2colorREL.put(currentKey, (int)((currentPondWeight / max) * 255)) ;
		}
		
	}

}
